﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

//int main()
//{
//	int a = 0;
//	scanf("%d", &a);
//	printf("%d\n", a);
//	return 0;
//}

//int main()
//{
//	//FILE* pf = fopen("text.txt", "w");
//	//绝对路径
//	//相对路径
//	//.表示当前路径
//	//..上一级路径
//	FILE* pf = fopen("./../test.c","w");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//
//
//
//	//关闭文件
//	fclose(pf);
//	pf = NULL;
//
//	return 0;
//}


//fputc函数，字符输出函数，字符输出到流里面，流自动工作将其运送到打开的文件里面
//返回值是int 就是扔进流字符的ASCII码值
//打开失败，返回NULL
//int main()
//{
//	FILE* pf = fopen("test.txt", "w");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	//写文件
//	/*fputc('x', pf);
//	fputc('i', pf);
//	fputc('a', pf);
//	fputc('o', pf);*/
//	char ch = 0;
//	for (ch = 'a'; ch < 'z'; ch++)
//	{
//		//fputc(ch, pf);
//		fputc(ch, stdout);
//		//printf("%c ", ch);
//	}
//
//
//	//关闭文件
//	fclose(pf);
//	pf = NULL;
//
//	return 0;
//}



//fgetc
//int fgetc(FILE* stream);
//读取文件数据，把他扔进流里面
//返回值也是int,ASCII码值
//If the stream is at the end-of-file when called, 
//the function returns EOF and sets the end-of-file indicator for the stream (feof).
//读取失败，返回EOF，文件不存在，也返回EOF，文件读取完成返回EOF
//int main()
//{
//	FILE* pf = fopen("test.txt", "r");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	//写文件
//	/*fputc('x', pf);
//	fputc('i', pf);
//	fputc('a', pf);
//	fputc('o', pf);*/
//
//	//读文件  读文件时，读完一次指针自动偏移一格。
//	int ch=fgetc(pf);
//	printf("%c\n", ch);
//
//	ch = fgetc(pf);
//	printf("%c\n", ch);
//
//	//关闭文件
//	fclose(pf);
//	pf = NULL;
//
//	return 0;
//}



//实现两个文件的拷贝
//int main()
//{
//	/*FILE* pread = fopen("text1.txt", "w");
//	if (pread == NULL)
//	{
//		perror("fopen-1");
//		return 1;
//	}
//	fputc('a', pread);
//	fputc('n', pread);
//	fputc('g', pread);
//	fputc('e', pread);
//	fputc('l', pread);
//	fputc('a', pread);
//	fputc('b', pread);
//	fputc('a', pread);
//	fputc('b', pread);
//	fputc('y', pread);*/
//	//先给文件写
//	FILE* pread = fopen("text1.txt", "r");
//	if (fopen == NULL)
//	{
//		perror("fopen-1");
//		return 1;
//	}
//	FILE* pwrite = fopen("text.txt", "w");
//	if (fopen == NULL)
//	{
//		perror("fopen-2");
//		fclose(pread);
//		pread = NULL;
//		return 1;
//	}
//	//读文件，写文件
//	//char ch;fgetc返回值为int ASCII码值
//	int ch;
//	while ((ch = fgetc(pread)) != EOF)
//	{
//		fputc(ch, pwrite);
//	}
//
//	//关闭文件
//	fclose(pread);
//	pread = NULL;
//	fclose(pwrite);
//	pwrite = NULL;
//	return 0;
//}



//int fputs ( const char * str, FILE * stream );
//Writes the C string pointed by str to the stream.
//成功时，将返回一个非负值。
//出错时，该函数返回文件结束标志（EOF）并设置错误指示符（ferror）。
//该函数从指定的地址（str）开始复制，直到遇到终止空字符（'\0'）。这个终止空字符不会被复制到流中。
//int main()
//{
//	FILE* pf = fopen("text.txt", "w");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	//写一行
//	fputs("hello world\n", pf);
//	fputs("baby\n", pf);
//	return 0;
//}



//fgets
//char* fgets(char* str, int num, FILE* stream);\
//从流中读取字符，并将它们作为 C 字符串存储到 str 中，直到读取了 (num - 1) 个字符，或者遇到换行符或文件结束符，以先发生者为准。
//换行符会使 fgets 停止读取，但该函数会将其视为有效字符，并包含在复制到 str 的字符串中。
//在复制到 str 的字符之后会自动追加一个终止空字符。


//int main()
//{
//	FILE* pf = fopen("text.txt", "r");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	char arr[] = "*******************";
//	fgets(arr, 5, pf);
//	printf("%s", arr);
//
//	fgets(arr, 5, pf);
//	printf("%s", arr);
// 
//	fclose(pf);
//	pf = NULL;
//	return 0;
//}


//fprintf
//int fprintf ( FILE * stream, const char * format, ... );
//将format所指向的 C 字符串写入流中。如果format包含格式说明符（以 % 开头的子序列），
//则format之后的附加参数将被格式化并插入到结果字符串中，替换各自的说明符。
//如果成功，将返回写入的字符总数。
//如果发生写入错误，将设置错误指示符（ferror）并返回一个负数。
//如果在写入宽字符时发生多字节字符编码错误，errno 将设置为 EILSEQ 并返回一个负数。

//struct S
//{
//	int a;
//	float b;
//	char c[20];
//};
//
//int main()
//{
//	struct S s = { .b = 38.90f,.a = 10,.c = "zjhd" };
//	FILE* pf = fopen("text.txt", "w");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	fprintf(pf, "%f %d %s", s.b, s.a, s.c);
// 
//	fclose(pf);
//	pf = NULL;
//	return 0;
//}


//int fscanf ( FILE * stream, const char * format, ... );
///从文件流中读取数据
//如果成功，该函数将返回成功填充的参数列表项数

//struct S
//{
//	int a;
//	float b;
//	char c[20];
//};
//
//int main()
//{
//	struct S s = { 0 };
//	FILE* pf = fopen("text.txt", "r");
//	if (pf == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	fscanf(pf, "%f %d %s", &(s.b), &(s.a), &(s.c));//输入到流里面
//	printf("%f %d %s", s.b, s.a, s.c);
// 
//	fclose(pf);
//	pf = NULL;
//	return 0;
//}


//printf-针对标准输出流的输出(从流中输出)函数
//scanf-针对输入流的输入(向流中输入)函数

//fscanf-针对所有输入流的格式输入函数
//fprintf-针对所有输出流的格式输出函数

//sscanf-从字符中读取格式化的数据
//sprintf-把格式化的数据转成字符串


//int sscanf ( const char * s, const char * format, ...);
//int sprintf(char* str, const char* format, ...);
//int main() {
//    const char* str = "123 3.14";
//    char str1[20]={0};
//    int num;
//    float f;
//
//    // 从字符串中读取整数和浮点数
//    sscanf(str, "%d %f", &num, &f);
//    //sprintf(str1, "%d %f", num, f);
//    printf("整数: %d\n", num);
//    printf("浮点数: %f\n", f);
//    sprintf(str1, "%d %f", num, f);//格式化数据转成字符串，每个元素都是一个字符
//    printf(str1);
//    return 0;
//}

//struct S 
//{
//	int a;
//	float b;
//	char arr[10];
//};
//int main()
//{
//	struct S s = { 100,3.14f,"arrrr" };
//	char arr[20];
//	sprintf(arr, "%d %f %s", s.a, s.b, s.arr);
//	printf(arr);
//
//
//
//	//从字符串中提取数据
//	struct S t = { 0 };
//	sscanf(arr, "%d %f %s", &(t.a), &(t.b), &(t.arr));
//	printf("%d %f %s", t.a, t.b, t.arr);
//	return 0;
//}

//size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
//将由 ptr 指向的内存块中包含 count 个元素的数组写入流中的当前位置，每个元素的大小为 size 字节。
int main()                         
{
	int arr[] = { 1,2,3,4,5,6,7,8,9 };
	FILE* ptr=fopen("text.txt", "wb");//二进制输出
	if (ptr == NULL)
	{
		perror("fopen");
		return 1;
	}
	fwrite(arr, sizeof(int), 7, ptr);//返回读到的元素个数
	//关闭文件
	fclose(ptr);
	ptr = NULL;
	return 0;
}



//int main()
//{
//	int arr[10] = { 0};
//	FILE* ptr=fopen("text.txt", "rb");//二进制输出
//	if (ptr == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	fread(arr, sizeof(int), 7, ptr);//返回读到的元素个数，返回值是否小于count来判断是否正常结束
//	int i = 0;
//	for (i = 0; i < 10; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	//关闭文件
//	fclose(ptr);
//	ptr = NULL;
//	return 0;
//}



//文件的随机读写  fseek ftell rewind
//int main()
//{
//	FILE* p = fopen("text.txt", "r");
//	if (p == NULL)
//	{
//		perror("fopen");
//		return 1;
//	}
//	fseek(p, 3, SEEK_SET);
//
//	int ch=fgetc(p);
//	printf("%c", ch);
//
//	ch = fgetc(p);
//	printf("%c", ch);
//
//	fseek(p, -3, SEEK_END);
//	ch = fgetc(p);
//	printf("%c", ch);
//	//ftell 偏移到哪里去了
//	int a=ftell(p);
//	printf("%d", a);
//
//
//	rewind(p);
//	ch=fgetc(p);
//	printf("%c", ch);
//	//关闭文件
//	fclose(p);
//	p = NULL;
//	return 0;
//}



//文件读取结束的判定
//ferror和feof



//#include <stdio.h>
//#include <stdlib.h>
//
//int main(void)
//{
//	int c; // 注意：int，⾮char，要求处理EOF 
//	FILE* fp = fopen("test.txt", "r");
//	if (!fp) {
//		perror("File opening failed");
//		return 1;
//	}
//	//fgetc 当读取失败的时候或者遇到⽂件结束的时候，都会返回EOF 
//	while ((c = fgetc(fp)) != EOF) // 标准C I/O读取⽂件循环 
//	{
//		printf("%c", c);
//	}
//	//判断是什么原因结束的 
//	if (ferror(fp))
//		puts("I/O error when reading");
//	else if (feof(fp))
//		puts("End of file reached successfully");
//
//	fclose(fp);
//}





//enum { SIZE = 5 };
//int main(void)
//{
//	double a[SIZE] = { 1.,2.,3.,4.,5. };
//	FILE* fp = fopen("test.bin", "wb"); // 必须⽤⼆进制模式 
//	fwrite(a, sizeof * a, SIZE, fp); // 写 double 的数组 
//	fclose(fp);
//
//	double b[SIZE];
//	fp = fopen("test.bin", "rb");
//	size_t ret_code = fread(b, sizeof *b, SIZE, fp); // 读 double 的数组 
//	if (ret_code == SIZE) {
//		puts("Array read successfully, contents: ");
//		for (int n = 0; n < SIZE; ++n) printf("%f ", b[n]);
//		putchar('\n');
//	}
//	else { // error handling
//		if (feof(fp))
//			printf("Error reading test.bin: unexpected end of file\n");
//		else if (ferror(fp)) {
//			perror("Error reading test.bin");
//		}
//	}
//
//	fclose(fp);
//}


//文件缓冲区

#include <windows.h>
//VS2019 WIN11环境测试 
//int main()
//{
//	FILE* pf = fopen("test.txt", "w");
//	fputs("abcdef", pf);//先将代码放在输出缓冲区 
//	printf("睡眠10秒-已经写数据了，打开test.txt⽂件，发现⽂件没有内容\n");
//	Sleep(10000);
//	printf("刷新缓冲区\n");
//	fflush(pf);//刷新缓冲区时，才将输出缓冲区的数据写到⽂件（磁盘） 
//	//注：fflush 在⾼版本的VS上不能使⽤了 
//	printf("再睡眠10秒-此时，再次打开test.txt⽂件，⽂件有内容了\n");
//	Sleep(10000);
//	fclose(pf);
//	//注：fclose在关闭⽂件的时候，也会刷新缓冲区 
//	pf = NULL;
//	return 0;
//}
